home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 1995 #5 & #6
/
Amiga Plus CD - 1995 - No. 5 and 6.iso
/
pd
/
serien
/
purity
/
nr.21
/
pcq-dokus
/
utils(include).anl
< prev
next >
Wrap
Text File
|
1995-04-23
|
37KB
|
1,207 lines
INCLUDE/UTILS
=============
Hinweise des Übersetzers:
- um die Funktionen und Prozeduren eines Include-Files zu benutzen, muß
{$I "Laufwerk:Verzeichnis/Name"}
verwendet werden. Ein Beispiel:
{$I "Include:Utils/Break.i"}
erlaubt die benutzung einer Funktion wie
BooleanVariable := CheckBreak;
In BooleanVariable steht dann TRUE, falls Ctrl-C gedrückt wurde, und
FALSE, wenn nicht. Eine andere Möglichkeit der Verwendung wäre
IF CheckBreak THEN exit;
Wurde Ctrl-C gedrückt, bricht das Programm ab.
- die in den einzelnen Kapiteln angegebenen Include-Files werden automatisch
von den angegebenen Include-Files geladen. Gibt man in einem Programm z.B.
{$I "Include:Utils/BuildMenu.i}
an, wird automatisch auch die Include-Datei
{$I "Include:Intuition/Intuition.i}
geladen, d.h. dies muß nicht nochmals angegeben werden
INHALTSVERZEICHNIS
^^^^^^^^^^^^^^^^^^
Include-Datei Kurzbeschreibung Zeile
1. Break.i ........... Unterbrechung ........................ 55
2. BuildMenu.i ....... Interface zum Menüsystem ............. 89
3. ConsoleIO.i ....... Console-Ein/Ausgabe .................. 175
4. ConsoleUtils.i .... Console-Utils (console.device) ....... 210
5. CRT.i ............. einige CRT-Routinen .................. 246
6. DateTools.i ....... Datum-Tools .......................... 375
7. DeadKeyConvert.i .. DeadKey-Konvertierung ................ 469
8. DOSUtils.i ........ DOS-Utils ............................ 493
9. DoubleBuffer.i .... einfacher Doppel-Puffer Mechanismus .. 515
10. IOUtils.i ......... Ein/Ausgabe-Utils .................... 559
11. MathTransUtils.i .. Utils für MathTrans.lib .............. 586
12. Parameters.i ...... Parameter ............................ 609
13. PCQMemory.i ....... PCQ-Speicher ......................... 635
14. Random.i .......... Zufallsgenerator ..................... 656
15. RunProgram.i ...... externe Programme starten ............ 690
16. SameName.i ........ Jokerzeichen ......................... 764
17. StringLib.i ....... C-String-Funktionen .................. 813
17. TaskUtils.i ....... Task-Utils ........................... 1010
18. TimerUtils.i ...... Uhr-Utils ............................ 1030
A. Register (Funktionen/Prozeduren-Übersicht) ............... 1063
B. Schlußwort des Übersetzers ............................... 1179
1. Break.i
----------
Hier wird CheckBreak deklariert, eine Funktion, die Euch mitteilt, ob der
Benutzer Ctrl-C gedrückt hat.
Sourcecode: Runtime/Extras.
Function
CheckBreak : Boolean;
External;
Gibt TRUE zurück, wenn der User Ctrl-C gedrückt hat.
2. BuildMenu.i
--------------
Diese Routinen bieten ein einfaches Interface zum Amiga-Menüsystem, ähnlich
zu dem von AmigaBASIC. Das Ganze geht natürlich auf Kosten der Flexibilität,
aber für viele Menüsysteme wird´s genügen.
Um diese Routinen zu benutzen, müßt Ihr erst ein Fenster öffnen. Danach muß
InitializeMenu aufgerufen und Euer "valid Window-Pointer" übergeben werden.
Beachtet, daß das Fenster dann schon offen sein muß!
Danach ruft NewMenu("Menu Name") mit jedem beliebigen Namen auf, um Euer 1.
Menü zu erstellen. Ruft dann NewItem("name", 'N') für jeden zu erzeugenden
Menüpunkt auf. NewMenu muß vor NewItem aufgerufen werden. Wenn Ihr keine Ta-
stenkombination für den Menüpunkt haben wollt, müßt Ihr '\0' (null) überge-
ben.
Wollt Ihr Untermenüpunkte für Eueren Menüpunkt, müßt Ihr NewSubItem mit den-
selben Parametern wie NewItem aufrufen. Beachtet, daß NewItem zumindest ein-
mal vor NewSubItem aufgerufen werden muß.
Beachtet auch, daß die Reihenfolge wichtig ist. Wenn Ihr beispielsweise die
Reihenfolge zweier Menüpunkte vertauscht wurde, erscheinen sie in umgekehr-
ter Reihenfolge im Menü. Alle Menüpunkte erscheinen auch unter dem zuletzt
definierten Menü. Beachtet außerdem, daß diese Routinen nur 1 Menüstreifen
auf einmal definieren.
Habt Ihr all das gemacht, könnt Ihr AttachMenu aufrufen, um den Benutzer das
Ansehen der Menüs und das Benutzen derer zu erlauben. Dann müßt Ihr aber den
IDCMP-Port des Fenster (window^.UserPort) überwachen, um MENUPICK_f-Mittei-
lungen zu erhalten, die Ihr mittes MenuNum() und ItemNum() entziffern könnt.
Siehe auch das "Intuition Manual" (wer´s denn hat - Anm.d.Ü.).
Wollt Ihr das Menü aus dem Fenster wieder entfernen, könnt Ihr DetachMenu
aufrufen, aber solange Ihr den Speicher nicht wieder freigebt (siehe unten),
könnt Ihr mittels AttachMenu wieder auf das Menü zugreifen. Ihr könnt auch
verschiedene Teile des Menüs mittels OnMenu() und OffMenu() in Geister-
schrift darstellen. Näheres befindet sich wieder im "Intuition Manual".
Um den Speicher eines Menüpunkts wieder freizugeben, müßt Ihr dann
DisposeMenu aufrufen. Habt Ihr das Menü nicht losgelöst (detached), gibt´s
früher oder später einen Systemabsturz. Der Speicher muß nicht unbedingt
freigegeben werden, da das am Programmende automatisch gemacht wird.
Das Menü muß aber vor dem Schließen des Fensters losgelöst werden.
Sourcecode: Runtime/Extras
{$I "Include:Intuition/Intuition.i" for WindowPtr }
Procedure
DisposeMenu;
External;
Gibt den Speicher des Menüpunkts wieder frei. Geht aber sicher, daß das Menü
nicht gerade angezeigt wird !!!
Procedure
InitializeMenu(w : WindowPtr);
External;
Erzeugt das BuildMenu System (bringt einige nützliche Voreinstellungen).
w muß dabei auf ein wahres, offenes Fenster zeigen.
Procedure
NewMenu(str : String);
External;
Fügt ein neues Menü an den Menüstreifen an. Zuvor muß InitializeMenu aufge-
rufen werden. Dies muß zumindest einmal vor NewItem oder NewSub aufgerufen
werden.
Procedure
NewItem(name : String; comm : Char);
External;
Fügt ein Item an das zuletzt definierte Menü an. Zuvor muß NewMenu aufgeru-
fen werden. 'name' ist der Text, der in der Box geschrieben werden soll, und
'comm' die equivalente Tastenkombination. Für keine equivalente Tastenkombi-
nation muß '\0' (NULL-Byte) verwendet werden.
Wenn Ihr alle Menüpunkte gleichlang macht (mittels Leerstellen am Ende), hat
der Benutzer es nachher einfacher, das Menü zu benutzen.
Procedure
NewSubItem(name : String; comm : Char);
External;
Fügt ein Untermenü zum aktuellen Menüpunkt hinzu. Zuvor muß NewItem aufgeru-
fen worden sein. Die Parameter usw. entsprechten denen von NewItem.
Procedure
AttachMenu;
External;
Fügt den erzeugten Menüstreifen an das im InitializeMenu-Aufruf angegebene
Fenster an. Dieser Befehl gibt die Struktur an Intuition weiter, das dann
die eigentliche Arbeit macht.
Procedure
DetachMenu;
External;
Entfernt das Menü vom Fenster, gibt den Speicher usw. nicht zurück. Ihr
könnt das Menü später mittels AttachMenu wieder anfügen. Um den Benutzer da-
von abzuhalten, ein best. Menü zu benutzen, ist es aber besser, OnMen() und
OffMenu() zu verwenden, insbesondere, wenn nur ein paar Menüpunkte gesperrt
werden sollen.
Diese Routine muß vor dem Schließen eines Fensters aufgerufen werden.
3. ConsoleIO.i
--------------
Hiermit wird das gesamte normale console.device Zeugs zum Arbeiten mit Fen-
stern implementiert. Der erste Satz an Routinen ist das Standard-Amiga-Zeug,
das im "ROM Kernel Manual" beschrieben ist. Ein Beispiel befindet sich unter
"ConsoleTest.p" im Verzeichnis "Examples".
Sourcecode: Runtime/Extras
{$I "Include:Exec/IO.i"}
{$I "Include:Exec/Ports.i"}
Procedure
ConPutChar(Request : IOStdReqPtr; Character : Char);
External;
Procedure
ConWrite(Request : IOStdReqPtr; Str : String; length : Integer);
External;
Procedure
ConPutStr(Request : IOStdReqPtr; Str : String);
External;
Procedure
QueueRead(Request : IOStdReqPtr; Where : String);
External;
Function
ConGetChar(consolePort : MsgPortPtr; Request : IOStdReqPtr;
WhereTo : String) : Char;
External;
4. ConsoleUtils.i
-----------------
Hier werden 2 Funktionen definiert, die einfach das console.device initiali-
sieren und schließen. Das wird mittels OpenDevice gemacht, wobei anschlies-
send ConsoleBase (definiert in Devices/Console.i) auf io_Device gesetzt
wird.
Siehe auch Utilis/ConsoleIO.i, Utils/CRT.i und - natürlich - Devices/Con-
sole.i.
Sourcecode: RunTime/Extras.
{$I "Include:Exec/IO.i"}
{$I "Include:Devices/Console.i"}
var
ConsoleRequest : IOStdReq;
Procedure
OpenConsoleDevice;
External;
Hiermit wird ein gültiger Zeiger oder Nil auf ConsoleBase assignt. Alles was
eigentlich gemacht wird, ist das Aufrufen von OpenDevice und das io_Device
Feld auszulesen. Auf jeden Fall müßt Ihr einen gültigen Zeiger auf Console-
Base zeigen lassen bevor Ihr RawKeyKonvert oder CDInputHandler aufruft.
Procedure
CloseConsoleDevice;
External;
Schließt das console.device.
5. CRT.i
--------
Diese Routinen sind ein einfacher Versuch einige der CRT-Routinen von Turbo
Pascal zu imitieren. Siehe auch "ConsoleTest.p" für ein Beispiel zur Benut-
zung.
Beachtet, daß ConsoleSetPtr, der eigentliche Typ, der von AttachConsole zu-
rückgegeben wird, hier nicht definiert ist.
Sourcecode: Runtime/Extras (unter CRT.p und CRT2.p).
{$I "Include:Intuition/Intuition.i"}
Function
AttachConsole(w : WindowPtr) : Address;
External;
Diese Funktion initialisiert die CRT-Routinen für ein bestimmtes Fenster.
Diese Routine gibt Nil zurück, wenn es ein Problem gegeben hat, oder den
Zeiger auf einen Record, der die wichtigen Informationen enthält, die der
Rest der Routinen benötigt.
AttachConsole muß vor allen anderen CRT-Routinen aufgerufen werden muß.
Procedure
ClrEOL(CRT : Address);
External;
Löscht von der Cursorposition bis zum Zeilenende.
Procedure
ClrScr(CRT : Address);
External;
Löscht den Textbereich des Fensters und bewegt den Cursor zu 1,1.
Procedure
CursOff(CRT : Address);
External;
Schaltet den Textcursor des console.device ab. Beachtet, daß dieser nicht
derselbe wie der Mauszeiger ist!
Procedure
CursOn(CRT : Address);
External;
Schaltet den Textcursor wieder ein.
Procedure
DetachConsole(CRT : Address);
External;
Schließt das console.device wieder und gibt den gesamten Speicher wieder
frei, der durch den AttachConsole Aufruf reserviert wurde.
Diese Routine muß aufgerufen werden, bevor das Programm abbricht und bevor
das Fenster geschlossen wird.
Procedure
GotoXY(CRT : Address; x,y : Short);
External;
Bewegt den Textcursor auf die angegebene Spalte und Zeile X,Y.
Procedure
InsLine(CRT : Address);
External;
Fügt eine Zeile an der aktuellen Cursorposition ein. Die aktuelle Zeile und
alle Zeilen darunter werden um eine nach unten verschoben.
Function
KeyPressed(CRT : Address) : Boolean;
External;
Gibt TRUE zurück, wenn eine Taste in der console wartet.
Function
MaxX(CRT : Address) : Short;
External;
Gibt die Spalte des Fensters an, in der das letzte Zeichen ausgegeben werden
kann.
Function
MaxY(CRT : Address) : Short;
External;
Gibt die letzte Zeile des Fensters zur Zeichenausgabe an.
Function
ReadKey(CRT : Address) : Char;
External;
Wartet auf den Druck einer Taste und gibt diese zurück. CRT ist ein Zeiger
auf den CRT-Record, zurückgegeben von AttachConsole. Beachtet, daß die Taste
nicht automatisch angezeigt wird - Ihr müßt dafür WriteString oder so aufru-
fen.
Procedure
TextColor(CRT : Address; t : Byte);
External;
Setzt die Vordergrund-Stiftnummer (Textfarbe). Die tatsächlich angezeigte
Farbe hängt von der aktuellen Farbpalette des Screens ab, wodurch Ihr
SetRGB4 (oder equivalentes) aufrufen müßt, um spezielle Werte zu bekommen.
Procedure
TextBackground(CRT : Address; t : Byte);
External;
Setzt die Hintergrundfarbe für den Text.
Function
WhereX(CRT : Address) : Short;
External;
Gibt die aktuelle Textcursor-Spalte an.
Function
WhereY(CRT : Address) : Short;
External;
Gibt die aktuelle Textcursor-Zeile an.
Procedure
WriteString(CRT : Address; Str : String);
External;
Schreibt einen String ins Fenster mittels des console.device. Der String
kann ANSI-Codes enthalten, um die Schiftfarben zu ändern, den Cursor zu be-
wegen, und vieles mehr!
6. DateTools.i
--------------
Diese Routinen helfen, die DateStamps von AmigaDOS und CurrentTime() von In-
tuizion zu benutzen, die, um Speicher zu sparen, relativ umständlich forma-
tiert sind. Diese Routinen benutzen DateDescription Records, die das Jahr,
den Monat und die Tagesnamen in einer menschlichen Form enthalten. Dieses
Module exportiert auch einige Typenkonstanten, die den Monat und die Tages-
namen richtig schreiben.
Die Monatsnamen- und Tagesnamen-Arrays können wenn nötig verändert oder ent-
fernt werden. Wenn Ihr z.B. nicht Englisch benutzt, könnt Ihr sie in diesem
File verändern und müßt Euch sonst nirgends darum kümmern. Wollt Ihr Spei-
cher sparen, könnt Ihr sie auch vollständig entfernen. Ihr könnt aber nicht
das DaysInMonth-Array loswerden, da das in den DateTools-Routinen verwendet
wird.
(das Verändern der Namen natürlich im Include-File vornehmen, nicht in die-
sem Doc-File! - Anm.d.Ü.)
{$I "Include:Libraries/DOS.i"}
Type
DaysOfTheWeek = (Sunday, Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday);
DateDescription = record
Day : Byte; { Day of month, 1..31 }
Month : Byte; { Month, 1..12 }
Year : Short; { Year, 1978... }
DOW : DaysOfTheWeek; { Sunday .. Saturday }
Hour : Byte; { 0..23. 0 = 12 AM, 12 = Noon }
Minute : Byte; { 0..59 }
Second : Byte; { 0..59 }
end;
Const
MonthNames : Array [1..12] of String =
("January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December");
DayNames : Array [Sunday..Saturday] of String =
("Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday");
Das folgende Feld verändert sich, wenn Ihr eine Datumbeschreibung für ein
Schaltjahrdatum haben wollt. Wollt Ihr also diese Werte verwenden, müßt Ihr
sichergehen, daß DaysInMonth[1] auf den benötigten Wert gesetzt wird. Beach-
tet auch, daß dieses Feld im Gegensatz zu den oben beschriebenen Monatsnamen
zero-based (d.h. mit 0 als Basis) ist.
DaysInMonth : Array [0..11] of Byte = (31,28,31,30,31,30,
31,31,30,31,30,31);
Procedure
GetDescription(Total : Integer; var DD : DateDescription);
External;
Diese Prozedur berechnet bei gegebenen Gesamtsekunden den Tag, Monat, Jahr,
Tageszeit usw.
Procedure
TimeDesc(var DD : DateDescription);
External;
Ermittelt eine Beschreibung der aktuellen Zeit.
Procedure
StampDesc(DS : DateStampRec; var DD : DateDescription);
External;
Ermittelt eine Beschreibung basierend auf einen DateStampRec.
7. DeadKeyConvert.i
-------------------
Hiermit wird lediglich die DeadKeyConvert-Funktion deklariert, um rohe Ta-
stendrücke zu "kochen" (vom Intuition). Mehr Infos darüber gibt´s im ROM
Kernal Manual und im Enhancer Manual.
Objektcode: in PCQ.lib
Sourcecode: Runtime/Extras
Ihr müßt vor der Benutzung dieser Funktion OpenConsoleDevice (definiert in
ConsoleUtils.i) aufrufen, da DeadKeyConvert RawKeyConvert aufruft.
{$I "Include:Intuition/Intuition.i"}
Benutzt Ihr diese Funktion ohne Intuition.i, was wohl recht selten sein
dürfte, solltet Ihr den Typ von "msg" in Address oder MassagePtr oder so
verändern. Somit müßt Ihr Intuition.i nicht includen, wenn Ihr nicht wollt.
Function
DeadKeyConvert(msg : IntuiMessagePtr; Buffer : String;
BufSize : Integer; KeyMap : Address) : Integer;
External;
8. DOSUtils.i
-------------
Ein paar Routinen, die die Benutzung von DOS etwas einfacher machen.
Sourcecode: Runtime/Extras
{$I "Include:Libraries/DOS.i"}
Function
APTRtoBPTR(a : Address) : BPTR;
External;
Function
BPTRtoAPTR(b : BPTR) : Address;
External;
Function
GetFileHandle(var f : Text) : FileHandle;
External;
9. DoubleBuffer.i
-----------------
Diese Routinen bieten einen sehr einfachen Doppelpuffer-Mechanismus, haupt-
sächlich dadurch, indem er ein bißchen inflexibel mit der Wahl von Screens
und Fenstern ist.
Das erste, was gemacht werden muß, ist eine NewScreen-Struktur zu erzeugen,
genau, wie Ihr das für OpenScreen machen würdet. Das kann jede Screen-Art
sein. Danach müßt Ihr OpenDoubleBuffer aufrufen, der einen Zeiger auf ein
Full-Screen-rahmenloses Backdrop-Fenster zurückgibt, oder Nil, falls irgend-
was schiefgelaufen ist.
Schreibt Ihr in den RastPort des Fensters, ist es unsichtbar, bis Ihr Swap-
Buffers aufruft. Übrigens könnt Ihr immer in denselben RastPort schreiben -
Ihr müßt nach SwapBuffers nicht reinitialisieren. Alles Puffer-Tauschen
läuft auf BitMap-Ebene ab, wodurch es transparent zu den RastPorts ist.
Seid Ihr fertig, müßt Ihr CloseDubbleBuffer aufrufen. Schließt Ihr das Fen-
ster und den Screen getrennt, könnte es zum Absturz kommen, zumindest aber
zum Speicherverlust.
Sourcecode: Runtime/Extras
Objektcode: PCQ.lib
Ein letzter Punkt: GfxBase muß offen sein, bevor Ihr OpenDoubleBuffer auf-
ruft. Wäre es nicht offen, wozu dann Doppelpuffer?
{$I "Include:Intuition/Intuition.i"}
Function
OpenDoubleBuffer(ns : NewScreenPtr) : WindowPtr;
External;
Procedure
SwapBuffers(w : WindowPtr);
External;
Procedure
CloseDoubleBuffer(w : WindowPtr);
External;
10. IOUtils.i
-------------
Dieses File enthält NewList, CreatePort, DeletePort, CreateStdIO und Delete-
StdIO. Beachtet dabei, daß diese Funktionen NICHT die Speicherroutinen von
PCQ benutzen. Schlägt das löschen davon fehl, ist der Speicher verloren.
Objektcode: PCQ.lib
Sourcecode: Runtime/Extras
{$I "Include:Exec/Ports.i"}
{$I "Include:Exec/IO.i"}
Function
CreatePort(Name : String; pri : Integer) : MsgPortPtr;
External;
Procedure
DeletePort(port : MsgPortPtr);
External;
Function
CreateStdIO(ioReplyPort : MsgPortPtr) : IOStdReqPtr;
External;
Procedure
DeleteStdIO(Request : IOStdReqPtr);
External;
11. MathTransUtils.i
--------------------
Ein paar Routinen, die die Benutzung der mathtrans.libarary etwas einfacher
machen. OpenMathTrans versucht die Library zu öffnen und gibt TRUE zurück,
wenn nichts schiefgelaufen ist. CloseMathTrans macht dasselbe wie Close-
Library(...), aber FlushMathTrans schließt die Library UND entfernt sie aus
dem Speicher, wenn niemand sie sonst derzeit benutzt.
Function
OpenMathTrans : Boolean;
External;
Procedure
CloseMathTrans;
External;
Procedure
FlushMathTrans;
External;
12. Parameters.i
----------------
Dies ist das Zeug, das zur Arbeit mit Kommandozeilen nötig ist, incl. der
Workbench-Mitteilung.
{$I "Include:Exec/Ports.i"}
{$I "Include:Workbench/Startup.i"}
Function GetStartupMsg : WBStartupPtr;
external;
Gibt den Workbench-Mitteilungs-Zeiger (WB-MessagePtr) zurück.
Procedure
GetParam(n : Short; S : String);
external;
Kopiert den abgefragten Parameter in den String S. S muß natürlich bereits
reserviert worden sein. Beachtet, daß die Parameter von der Kommandozeile
oder der Workbench-Mitteilung sein können. S ist ein String der Länge 0 (in
anderen Worten S^ = Chr(0)), wenn der Parameter nicht existiert.
13. PCQMemory.i
---------------
Diese Routinen reservieren sogenannten PCQ-Speicher und geben ihn wieder
frei. Sie sind enthalten, um kompatibler mit TurboPascal zu sein, und in
zukünftigen Versionen von PCQ werden sie Standardprozeduren sein.
Procedure
GetMem(var p : Address; Size : Integer);
External;
Reserviert Systemspeicher und übergibt das Ergebnis in p.
Procedure
FreePCQMem(var p : Address; Size : Integer);
External;
Gibt Speicher frei, der mit GetMem reserviert wurde.
14. Random.p
------------
Hier ist ein sehr langer zyklischer Zufallszahlengenerator, der durch die
Verbindung dreier unabhängiger Generatoren erzeugt wurde. Die Technik wurde
in der Ausgabe 3/87 des Byte-Magazins.
Sourcecode: Runtime/Extras.
Function
RealRandom : Real;
External;
Gibt einen Real-Wert zwischen 0 und 1 zurück.
Function
RangeRandom(MaxValue : Integer) : Integer;
External;
Gibt einen Integer-Wert zwischen 0 und MaxValue (inclusive) zurück.
Procedure
UseSeed(seed : Integer);
External;
Setzt die Grundlagen abhängig vom übergebenen Wert.
Procedure SelfSeed;
External;
Setzt die Grundlagen abhängig von der Systemuhr.
15. RunProgram.i
----------------
Diese Routinen erlauben das Starten von Diskfiles oder von Segmenten, die
Ihr als separate Prozesse geladen habt, d.h., daß sie AmigaDOS genau wie Ih-
re Ursache benutzen können. Tasks, die Ihr wieder aufruft, sind viel einfa-
cher, können aber keine DOS IO-Routinen (Ein/Ausgabe) benutzen, wobei auch
Write() und Read() enthalten sind.
Programme, die mit diesen Routinen gestartet wurden, denken, daß sie von der
Workbench gestartet worden sind, somit müssen sie dies behandeln können. Die
typischen CLI-Befehle wie "dir" und "copy" laufen NICHT mit diesen Routinen.
Die meisten PCQ-Pascal-Programme dürften aber damit keine Probleme haben.
Da diese Programme wie Workbenchprogramme gestartet werden, könnt Ihr auch
nicht einfach eine Kommandozeile übergeben. Das läßt beispielsweise das Lau-
fenlassen des Pascal-Compilers aus...solange Ihr mit der Workbench-Startup-
Mitteilung rumspielt, was für den Compiler klar ist. Das mag mit manchen
PCQ-Pascal-Programmen laufen, mit manchen aber auch nicht.
Da diese Routinen die normalen PCQ-Speicherreservierungsschemen benutzen,
kann das aufrufende Programm nicht beendet werden, bevor alle daraus aufge-
rufenen Programme fertig sind.
Der einfachste Weg, um diese Routinen zu benutzen, ist das Aufrufen von Run-
Program. Der Aufruf sieht so aus wie:
if RunProgram("path/filename", 4000) then
writeln('program ran OK')
else
writeln('problem running program');
Denkt daran, daß nicht alle Programm mittels dieser Routinen gestartet wer-
den können. PCQ-Programme können es wahrscheinlich, es wäre aber nicht ver-
wunderlich, wenn es in manchen Fällen Probleme gäbe.
Sourcecode: Runtime/Extras
type
RunProgPtr = Address;
Diese Adresse wird von den "No Wait" Funktionen zurückgegeben. Sie zeigt auf
einen Record, der alle Speicher- und sonstigen vom Programm reservierte Rou-
tinen im Auge behält. Dieser Record ist der Schlüssel zu diesen Routinen.
Function
RunSegmentNW(ProcName : String;
Segment : Address;
StackSize : Integer) : RunProgPtr;
External;
Wenn Ihr bereits ein Segment geladen habt, wird das Segment als ein Prozeß
gestartet und sofort zurückgekehrt. Ist irgendwas schiefgelaufen, gibt diese
Routine Nil zurück. Ansonsten läuft der neue Prozeß schon, wenn diese Routi-
ne zurückkehrt.
Function
RunProgramNW(FileName : String; StackSize : Integer) : RunProgPtr;
External;
Läd ein File und startet es als Prozeß. Kehrt zurück, ohne darauf zu warten,
bis dieses neue Programm fertig ist. Ist irgendwas schiefgelaufen, gibt die-
se Routine Nil zurück. Ansonsten läuft das Programm schon.
Procedure
FinishProgram(RP : RunProgPtr);
External;
Wartet auf die Beendigung des Prozesses und gibt dann alles durch die Run-
Routinen reservierte wieder frei. Wenn Ihr das Programm mit RunSegmentNW ge-
startet habt (z.B. wenn Ihr schon ein Programm geladen hattet), wird diese
Routine Euer Segment nicht UnLoadSeg´en. D.h. diese Routine gibt alles durch
die Run-Routinen reservierte wieder frei, aber sonst nichts.
Function
RunProgram(FileName : String; StackSize : Integer) : Boolean;
External;
Startet das genannte Programm als ein Prozeß und wartet bis dieser neue Pro-
zeß fertig ist, bevor er zurückkehrt. Lief der Prozeß OK, gibt diese Routine
TRUE zurück, ansonsten FALSE.
Function
RunSegment(ProcName : String;
Segment : Address;
StackSize : Integer) : Boolean;
External;
Habt Ihr - warum auch immer - bereits ein Segment geladen, könnt Ihr diese
Routine aufrufen, um dieses Segment als Prozeß laufen zu lassen und dann vor
dem Zurückkehren auf die Beendigung dieses Prozesses zu warten. Ist irgend-
was schiefgelaufen, gibt diese Routine FALSE zurück, ansonsten TRUE.
Function
ProgramFinished(RP : RunProgPtr) : Boolean;
External;
Ist der Prozeß, auf den RP zeigt, fertig, wird der gesamte Speicher freige-
geben, den diese Routinen reserviert haben und TRUE zurückgegeben. Wenn
nicht, wird FALSE zurückgegeben. Wie FinishProgram gibt diese Routine auch
nur Systemresourcen frei, die von RunSomething-Routinen reserviert wurden.
16. SameName.i
--------------
Dieses Include-File beinhaltet nur eine Funktion: SameName.
Diese Routine implementiert die einfachsten Teile der AmigaDOS-Mustererken-
nung (Jokerzeichen). Derzeit sind das nur die # und ? Operatoren zuzüglich
dem einfachen Anführungszeigen ', der vor # und ? bedeutet, daß diese als
normales Zeichen interpretiert werden sollen. Mehr dazu im AmigaDOS-Hand-
buch.
Sourcecode: Runtime/Extras
Objektcode: PCQ.lib
Function
SameName(Mask, Target : String) : Boolean;
External;
17. StringLib.i
---------------
Hier sind ein paar der gewöhnlichen C-String-Funktionen:
Function
isupper(c : Char) : Boolean;
External;
Gibt TRUE zurück, wenn das Zeichen in A..Z ist.
Function
islower(c : Char) : Boolean;
external;
Gibt TRUE zurück, wenn das Zeichen in a..z ist.
Function
isalpha(c : Char) : Boolean;
external;
Gibt TRUE zurück, wenn das Zeichen in A..Z oder a..z ist.
Function isdigit(c : Char) : Boolean;
external;
Gibt TRUE zurück, wenn das Zeichen in 0..9 ist.
Function
isalnum(c : Char) : Boolean;
external;
Gibt TRUE zurück, wenn ifalpha oder isdigit wahr ist.
Function
isspace(c : Char) : Boolean;
external;
Gibt TRUE zurück, wenn das Zeichen eine "weiße Leerstelle ist", wie z.B.
Leerzeichen (Space), Formfeed, Linefeed, Carriage Return, Tabulatoren, usw.
Function
toupper(c : Char) : Char;
external;
Ist das Zeichen in a..z, gibt diese Funktion den zugehörigen Großbuchstaben
aus. Ansonsten gibt sie c zurück.
Function
tolower(c : Char) : Char;
external;
Ist c in A..Z, gibt diese Funktion den zugehörigen Kleinbuchstaben aus.
Ansonsten gibt sie c zurück.
Function
streq(s1, s2 : String) : Boolean;
external;
Gibt TRUE zurück, wenn s1 und s2 identisch sind.
Function
strneq(s1, s2 : String; n : Short) : Boolean;
external;
Gibt TRUE zurück, wenn die ersten n Zeichen von s1 und s2 identisch sind.
Function
strieq(s1, s2 : String) : Boolean;
external;
Entspricht streq(), ist aber Case Insensitive (achtet nicht auf Groß/Klein-
schreibung).
Function
strnieq(s1, s2 : String; n : Short) : Boolean;
external;
Entspricht strneq(), ist aber Case Insensitive.
Function
strcmp(s1, s2 : String) : Integer;
external;
Gibt einen Integer-Wert < 0 zurück, wenn s1 < s2, 0 wenn sie gleich sind und
> 0 wenn s1 > s2. Beachtet, daß die zurückgegebenen Werte in 1.0 immer -1, 0
und 1 waren, was seit Version 1.1 nicht mehr der Fall ist.
Function
stricmp(s1, s2 : String) : Integer;
external;
Entspricht strcmp, ist aber Case Insensitive.
Function
strncmp(s1, s2 : String; n : Short) : Integer;
external;
Entspricht strcmp(), beachtet aber nur die ersten n Zeichen.
Function
strnicmp(s1, s2 : String; n : Short) : Integer;
external;
Entspricht strncmp, ist aber Case Insensitive.
Function
strlen(s : String) : Integer;
external;
Giubt die Zeichenanzahl im String an. Beachtet, daß Ihr strlen(s) + 1 Bytes
benötigt, um den String zu halten, da die abschließende Null nicht in der
Länge berücksichtigt wird.
Procedure
strcpy(s1, s2 : String);
external;
Kopiert s2 nach s1 und hängt dabei eine beendende Null an. Dies ist dasselbe
wie C, aber anders als in V1.0.
Procedure
strncpy(s1, s2 : String; n : Short);
external;
Kopiert s2 nach s1, mit einem Maximum von n Zeichen. Hängt eine Null am Ende
an.
Procedure
strcat(s1, s2 : String);
external;
Hängt s2 ans Ende von s1 an.
Procedure
strncat(s1, s2 : String; n : Short);
external;
Hängt höchstens n Zeichen von s2 an s1 an.
Function
strdup(s : String) : String;
External;
Erzeugt eine Kopie des Strings "s" und gibt einen Zeiger zurück.
Function
strpos(s1 : String; c : Char) : Integer;
external;
Gibt die Position (beginnend mit 0) der ersten (am weitesten links auftre-
tenden) Stelle von c in s1 zurück. Ist kein c enthalten, gibt es -1 zurück.
Function
strrpos(s1 : String; c : Char) : Integer;
external;
Gibt den Integer-Wert der am weitesten rechts stehenden Position von c in s1
zurück. Ist c nicht in s1, wird -1 zurückgegeben.
Function
Hash(s : String) : Short;
external;
Gibt den Hash-Wert von s zurück, berechnet die die AmigaDOS-Hash-Funktion.
Ihr müßt diesen Wert (mittels AND und MOD) auf die Größe, die Ihr braucht,
zurückschneiden.
Function
IntToStr(s : String; i : Integer) : Integer;
External;
Konvertiert i in seine Zeichenrepräsentation in s. Ist i kleiner als 0, be-
ginnt der String mit einem Minus-Zeichen. Es gibt keine Extra-Leerstellen
vor oder nach der Zahl. IntToStr gibt die Länge des erzeugten Strings zu-
rück, die zwischen 1 und 11 ist.
Function
AllocString(l : Integer) : String;
external;
Reserviert l Bytes und gibt einen Zeiger auf den reservierten Speicher zu-
rück. Dieser Speicher wird durch die New()-Funktion reserviert, wodurch er
am Programmende ans System zurückgegeben wird. Beachtet, daß der korrekte
Speicherbedarf strlen(s) + 1 ist.
Procedure
FreeString(s : String);
external;
Gibt den Speicher, der von AllocString reserviert wurde, ans System zurück.
Da der Amiga ein Multitasking-Computer ist, solltet Ihr den Speicher, den
Ihr nicht benötigt, immer ans System zurückgeben.
18. TaskUtils.i
---------------
Hier werden die Task-Unterstützungs-Routinen CreateTask und DeleteTask de-
klariert.
Sourcecode: Runtime/Extras.
{$I "Include:Exec/Tasks.i"}
Function
CreateTask(name : String; pri : Byte;
initPC : Address; stackSize : Integer) : TaskPtr;
External;
Procedure
DeleteTask(tc : TaskPtr);
External;
19. TimerUtils.i
----------------
Hier werden CreateTimer, WaitTimer und DeleteTimer deklariert. Sie erlauben
die Benutzung des timer.device mit relativ wenig Overhead. Beachtet aber,
daß im Gegensatz zu den Beispielen im ROM Kernel Manual diese Routinen das
VBlank-Unit verwenden. Dadurch benötigen sie viel weniger Overhead; Ihr
solltet diese Routinen aber nicht für Zeiten kürzer als eine halbe Sekunde
benutzen.
Sourcecode: Runtime/Extras
{$I "Include:Exec/Ports.i"}
{$I "Include:Devices/Timer.i"}
Function
CreateTimer : TimeRequestPtr;
External;
Function
SetTimer(WhichTimer : TimeRequestPtr;
Seconds, Microseconds : Integer) : MsgPortPtr;
External;
Procedure
WaitTimer(WhichTimer : TimeRequestPtr;
Seconds, Microseconds : Integer);
External;
Procedure
GetSysTime(WhichTimer : TimeRequestPtr; VAR TV : TimeVal);
External;
Procedure
DeleteTimer(WhichTimer : TimeRequestPtr);
External;
Anhang A: Register
------------------
Funktion/Prozedur Typ Kap Zeile
AllocString() ..... F 16 988
APTRtoBPTR() ...... F 8 502
AttachConsole() ... F 5 259
AttachMenu ........ P 2 154
BPTRtoAPTR() ...... F 8 506
CheckBreak ........ F 1 62
CloseConsoleDevice. P 4 239
CloseDubbleBuffer() P 9 554
CloseMathTrans .... P 11 600
ClrEOL() .......... P 5 269
ClrScr() .......... P 5 275
ConGetChar() ...... F 3 204
ConPutChar() ...... P 3 188
ConPutStr() ....... P 3 196
ConsoleRequest .... V 4 227
ConWrite() ........ P 3 192
CreatePort() ...... F 10 572
CreateStdIO() ..... F 10 578
CreateTask() ...... F 17 1016
CreateTimer() ..... F 18 1040
CursOff() ......... P 5 281
CursOn() .......... P 5 288
DateDescription ... T 6 405
DayNames .......... C 6 430
DaysInMonth ....... C 6 445
DaysOfTheWeek ..... T 6 402
DeadKeyConvert() .. F 7 487
DeletePort() ...... P 10 575
DeleteStdIO() ..... P 10 581
DeleteTask() ...... P 17 1021
DeleteTimer() ..... P 18 1054
DetachConsole() ... P 5 294
DetachMenu ........ P 2 162
DisposeMenu ....... P 2 113
FinishProgram() ... P 15 755
FlushMathTrans .... P 11 604
FreePCQMem() ...... P 13 649
FreeString() ...... P 16 997
GetDesription() ... P 6 449
GetFileHandle() ... F 8 510
GetMem() .......... P 13 643
GetParam() ........ P 12 625
GetStartupMsg ..... F 10 619
GetSysTime() ...... P 18 1052
GotoXY() .......... P 5 303
Hash()............. F 16 971
InizializeMenu() .. P 2 120
InsLine() ......... P 5 309
IntToStr() ........ F 16 979
IsAlNum() ......... F 16 839
IsAlpha() ......... F 16 827
IsDigit() ......... F 16 833
IsLower() ......... F 16 821
IsSpace() ......... F 16 845
IsUpper() ......... F 16 815
KeyPressed() ...... F 5 316
MaxX() ............ F 5 322
MaxY() ............ F 6 329
MonthNames ........ C 6 416
NewItem() ......... P 2 135
NewMenu() ......... P 2 127
NewSubItem() ...... P 2 147
OpenConsoleDevice . P 4 230
OpenDoubleBuffer(). F 9 546
OpenMathTrans ..... F 10 596
ProgramFinished() . F 15 784
QueueRead() ....... P 3 200
RangeRandom() ..... F 14 671
ReadKey() ......... F 5 335
RealRandom ........ F 14 665
RunProgPtr ........ T 15 729
RunProgram() ...... F 15 765
RunProgramNW() .... F 15 747
RunSegment() ...... F 15 773
RunSegmentNW() .... F 15 736
SameName() ........ F 16 808
SelfSeed .......... P 14 683
SetTimer() ........ F 18 1043
StampDesc() ....... P 6 462
StrCat() .......... F 16 939
StrCmp() .......... F 16 891
StrCpy() .......... F 16 925
StrDup() .......... F 16 951
StrEq() ........... F 16 866
StrICmp() ......... F 16 899
StrIEq() .......... F 16 878
StrLen() .......... F 16 917
StrnCat() ......... F 16 945
StrnCmp() ......... F 16 905
StrnCpy() ......... F 16 932
StrnEq() .......... F 16 872
StrnICmp() ........ F 16 911
StrnIEq() ......... F 16 885
StrPos() .......... F 16 957
StrRPos() ......... F 16 964
SwapBuffers() ..... P 9 550
TextBackground() .. P 5 352
TextColor() ....... P 5 344
TimeDesc() ........ P 5 456
ToLower() ......... F 16 859
ToUpper() ......... F 16 852
UseSeed() ......... P 14 677
WaitTimer() ....... P 18 1047
WhereX() .......... F 5 358
WhereY() .......... F 5 364
WriteString() ..... P 5 370
Typ: F = Funktion, P = Prozedur; C = Konstante, T= Typ, V = Variable
Anhang B: Schlußwort des Übersetzers
------------------------------------
Das wären soweit alle Funktionen, Prozeduren usw. der Includes im Verzeichnis
Utils. Diese Übersetzung ist nahezu 100 % vollständig, es wurden allerdings
ein paar wenige Sachen gekürzt oder hinzugefügt.
Dieses Docfile kam wiefolgt zustande: Zunächst wurden alle Include-Files an-
einandergehängt und in Kapitel unterteilt. Anschließend wurden sie übersetzt
(die engl. Originale sind die Include-Dateien selbst). Schließlich wurde
noch ein Inhaltsverzeichnis und ein Register angefügt.
Alle Angaben ohne Gewähr! - Solltet Ihr mit dem oben beschriebenen irgendwas
zerstören, seid Ihr selbst schuld, und nicht ich (der Übersetzer) !!!
Dieses Dok-File ist © copyright 8/93 by Stefan Grad (GPD). Verbreitung nur
gemeinsam mit dem PCQ-Pascal-Compiler erlaubt (zu den Bedingungen, die in
der zugehörigen deutschen Anleitung abgedruckt sind!). Ausgenommen davon ist
die Purity-Serie, da der PCQ-Pascal-Compiler hier schon auf der Disk-Nr. 6
zu finden ist.